<?php

   if ( !defined( "RUTA_FISICA_SISTEMA" ) )
      {
         // include_once '../../../config/Constantes.php';
         //include_once './sistema/config/Constantes.php';
         require_once "../../../../config/Constantes.php";
      }
   $ruta_sistema = RUTA_FISICA_SISTEMA . "/sistema/";
      
   require_once $ruta_sistema . "general/clases/comun/ConfiguracionGeneral.php";
   
/** 
 * @author juanjo
 * 
 * 
 */
class OperacionArchivo
   {
      private static $contenido_directorio; // Almacena el contenido del directorio que se recorre de forma recursiva
      private static $f_open;

      function __construct( )
         {
         }

      //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /*                                                 METODOS QUE TRABAJAN CON ARCHIVOS                                         */
      //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /**
       *
       * Metodo: existeArchivoCarpeta
       * Descripcion: Verifica si existe un archivo o carpeta
       * Fecha de Creacion: 05/03/2012 15:50:55
       * Autor: Juan José Muñiz Juárez
       * params: @param unknown_type $archivo_carpeta
       * params: @param unknown_type $archivo
       * params: @return boolean
       * return: boolean
       */
      private static function existeArchivoCarpeta( $archivo_carpeta, $archivo = false )
         {
            if ( $archivo )
               {
                  if ( isset( $archivo_carpeta ) )
                     {
                        if ( file_exists( $archivo_carpeta ) )
                           {
                              return true;
                           }
                     }
               }
            else
               {
                  if ( file_exists( $archivo_carpeta ) && is_dir( $archivo_carpeta ) )
                     {
                        return true;
                     }
               }
            return false;
         }

         /**
          * 
          * Nombre         	: 	generarDirectorio
          * Descripcion   	:	
          * Version 			:  	1.0
          * Autor:			:	Juan Jose Muñiz Juarez
          * Fecha y Hora		:	06/05/2012, 15:35:39
          * @param unknown_type $destino
          * @return boolean
          */
      public static function generarDirectorio( $destino )
         {
            //echo "Generando";
            
            if ( is_dir( $destino ) )
               {
                  return true;
               }

            //echo "Empieza";   
            $directorios = explode( '/', $destino );
            $directorio = '';

            $sistema_operativo = 1;
            
            $contador = 0;
           // var_dump( $directorios );
            foreach ( $directorios as $dir )
               {
                  if ( $contador > 0 )
                    {  
                        if ( empty( $dir ) || ( $dir == '.' ) || $dir == ".." )
                           {
                              continue;
                           }
      
                        $directorio .= '/' . $dir;
      
                        if ( !self::existeCarpeta( $directorio ) )
                          {
                             $ok = self::crearDirectorio( $directorio );
                          }
                    }
                  else
                    {
                       $directorio = $dir;
                    } 

                   $contador++; 
               }

            clearstatcache( );

            return is_dir( $destino );
         }

         /**
          * 
          * Nombre         	: 	crearDirectorio
          * Descripcion   	:	
          * Version 			:  	1.0
          * Autor:			:	Juan Jose Muñiz Juarez
          * Fecha y Hora		:	06/05/2012, 15:44:56
          * @param unknown_type $directorio
          */
      public static function crearDirectorio( $directorio )
        {
           if ( !$directorio )
             {
                
             }
             
           if ( !self::existeCarpeta( $directorio ) )
             {
                $creado = mkdir( $directorio );
                
                if ( $creado )
                  {
                     chmod( $directorio, 777 );
                  }
                  
                return $creado;  
             }  
             
           return false;  
        }   
         
      /**
       * 
       * Metodo: existeArchivo
       * Descripcion: 
       * Fecha de Creacion: 26/03/2012 15:49:34
       * Autor: Juan José Muñiz Juárez
       * params: @param unknown_type $file
       * return: return_type
       */
      public static function existeArchivo( $file )
         {
            return self :: existeArchivoCarpeta( $file, true );
         }

      /**
       * 
       * Metodo: existeCarpeta
       * Descripcion: 
       * Fecha de Creacion: 26/03/2012 15:50:12
       * Autor: Juan José Muñiz Juárez
       * params: @param unknown_type $file
       * params: @return boolean
       * return: boolean
       */
      public static function existeCarpeta( $file )
         {
            return self :: existeArchivoCarpeta( $file );
         }

      /**
       *
       * Metodo: obtenerArrayArchivosDirectorio
       * Descripcion: Permite obtener un arreglo de los archivos y directorios existentes en la carpeta que se pasa como parametro
       * Fecha de Creacion: 05/03/2012 16:38:52
       * Autor: Juan José Muñiz Juárez
       * params: @param unknown_type $carpeta_base // Carpeta que se escaneara para obtener archivos y directorios
       * params: @param unknown_type $directorio_recursivo // Hara una busqueda recursiva en las subcarpetas, por default es true
       * params: @return NULL
       * return: devuelve un arreglo con los archivos y carpetas existentes en la carpeta que se paso como parametro
       */
      public static function obtenerArrayArchivosDirectorio( $carpeta_base, $directorio_recursivo = true )
         {
            if ( isset( $carpeta_base ) )
               {
                  if ( self :: existeCarpeta( $carpeta_base ) )
                     {
                        self :: $contenido_directorio = array ( );
                        self :: leerDirectorio( $carpeta_base, $directorio_recursivo );

                        //var_dump(self :: $contenido_directorio );
                        if ( isset( self :: $contenido_directorio ) )
                           {
                              return ( self :: $contenido_directorio );
                           }
                     }
               }
            return null;
         }

      /**
       *
       * Metodo: leerDirectorio
       * Descripcion: Permite leer el contenido de un directorio, y esto se puede hacer recursivamente para las subcarpetas
       *
       * Fecha de Creacion: 05/03/2012 16:37:40
       * Autor: Juan José Muñiz Juárez
       * params: @param unknown_type $carpeta_base // Carpeta de la cual se van a obtener los registros
       * params: @param unknown_type $directorio_recursivo // Se obtendran las subcarpetas
       * return: return_type
       */
      private static function leerDirectorio( $carpeta_base, $directorio_recursivo )
         {
            if ( isset( $carpeta_base ) )
               {
                  if ( is_dir( $carpeta_base ) )
                     {
                        if ( $dir = opendir( $carpeta_base ) )
                           {
                              while ( ( $file = readdir( $dir ) ) !== false )
                                 {

                                    //solo si el archivo es un directorio, distinto que "." y ".."
                                    if ( $file != "." && $file != ".." )
                                       {
                                          /*echo "Archivo: " . $carpeta_base . "/" . $file ;
                                          echo "<br />";
                                          echo is_dir ( $carpeta_base . "/" . $file );
                                          echo "<br />";*/
                                          $folder_file = $carpeta_base . "/" . $file;

                                          if ( is_dir( $folder_file ) )
                                             {
                                                if ( $directorio_recursivo )
                                                   {
                                                      self :: leerDirectorio( $folder_file, $directorio_recursivo );
                                                   }
                                             }
                                          else
                                             {
                                                // echo "<br /> Archivo: $carpeta_base$file ";
                                                self :: $contenido_directorio [ ] = array ( "Carpeta" => $carpeta_base, "Archivo" => $file );
                                             }
                                       }
                                 }
                           }
                        closedir( $dir );
                     }
               }
         }

      /**
       *
       * Metodo: guardarContenidoArray
       * Descripcion:
       * Fecha de Creacion: 14/03/2012 15:17:57
       * Autor: Juan José Muñiz Juárez
       * params: @param unknown_type $file
       * params: @param unknown_type $contenido
       * params: @param unknown_type $posicion
       *                                        0 : Principio
       *                                        1 : Final del Archivo
       * return: return_type
       */
      public static function guardarContenidoArray( $file, $contenido, $ultimo_registro = true )
         {
            $continuar = true;

            /* if ( $remplazar_archivo === true )
               {
                  $continuar = self::eliminarArchivo( $file ); 
                  $modo = FILE_TIPO_ACCESO_ESCRITURA;
               }
             else 
               {   */ 
            if ( self :: existeArchivo( $file ) )
               {
                  $modo = ConfiguracionGeneral::get( "FILE_TIPO_ACCESO_LECTURA_ESCRITURA_FINAL" );
               }
            else
               {
                  $modo = ConfiguracionGeneral::get( "FILE_TIPO_ACCESO_ESCRITURA" );
               }
            //}

            if ( $continuar )
               {
                  try {
                     if ( !self :: $f_open )
                        {
                           self :: abrirConexionArchivo( $file, $modo );
                        }

                     if ( $contenido )
                        {
                           if ( is_array( $contenido ) && count( $contenido ) )
                              {
                                 self :: escribirArrayArchivo( $contenido, self :: $f_open );
                              }
                        }

                     if ( $ultimo_registro )
                        {
                           self :: cerrarConexionArchivo( );
                        }
                  }
                  catch ( Exception $ex ) {

                  }
               }
         }

      /**
       * 
       * Metodo: cerrarConexionArchivo
       * Descripcion: 
       * Fecha de Creacion: 27/03/2012 09:34:08
       * Autor: Juan José Muñiz Juárez
       * params: 
       * return: return_type
       */
      public static function cerrarConexionArchivo( )
         {
            if ( self :: $f_open )
               {
                  fclose( self :: $f_open );
                  self :: $f_open = null;
               }
         }

      /**
       * 
       * Metodo: abrirConexionArchivo
       * Descripcion: 
       * Fecha de Creacion: 27/03/2012 09:34:11
       * Autor: Juan José Muñiz Juárez
       * params: @param unknown_type $file
       * params: @param unknown_type $modo
       * return: return_type
       */
      public static function abrirConexionArchivo( $file, $modo )
         {
            if ( !self :: $f_open )
               {
                  //self::cerrarConexionArchivo();
                  /* }   
                  else
                   {  */
                  self :: $f_open = fopen( $file, $modo );
               }
         }

      /**
       * 
       * Metodo: escribirArrayArchivo
       * Descripcion: 
       * Fecha de Creacion: 26/03/2012 22:48:35
       * Autor: Juan José Muñiz Juárez
       * params: @param unknown_type $contenido
       * params: @param unknown_type $f_open
       * return: return_type
       */
      private static function escribirArrayArchivo( $contenido, $f_open )
         {
            if ( $contenido )
               {
                  if ( is_array( $contenido ) )
                     {
                        foreach ( $contenido as $datos )
                           {
                              if ( is_array( $datos ) )
                                 {
                                    /* echo "<br/>Datos[";
                                     var_dump( $datos );
                                     echo "]";*/
                                    self :: escribirArrayArchivo( $datos, $f_open );
                                 }
                              else
                                 {
                                    /* echo "<br/>";
                                      echo "Escribiendo datos: ";
                                      var_dump( $datos );*/
                                    fwrite( $f_open, $datos . PHP_EOL );
                                 }
                           }
                     }
                  else
                     {
                        fwrite( $f_open, $contenido . PHP_EOL );
                     }
               }
         }

      /**
       * 
       * Metodo: guardarArchivoContenidoSimple
       * Descripcion: 
       * Fecha de Creacion: 26/03/2012 16:22:33
       * Autor: Juan José Muñiz Juárez
       * params: @param unknown_type $file
       * params: @param unknown_type $contenido
       * params: @param unknown_type $posicion
       * params: @param unknown_type $remplazar_archivo
       * return: return_type
       */
      public static function guardarArchivoContenidoSimple( $file, $contenido, $remplazar_archivo = true )
         {
            $continuar = true;

            if ( $remplazar_archivo === true )
               {
                  $continuar = self :: eliminarArchivo( $file );
                  $modo = ConfiguracionGeneral::get( "FILE_TIPO_ACCESO_ESCRITURA" );
               }
            else
               {
                  if ( self :: existeArchivo( $file ) )
                     {
                        $modo = ConfiguracionGeneral::get( "FILE_TIPO_ACCESO_LECTURA_ESCRITURA_FINAL" );
                     }
                  else
                     {
                        $modo = ConfiguracionGeneral::get( "FILE_TIPO_ACCESO_ESCRITURA" ); 
                     }
               }

            if ( $continuar )
               {
                  try {
                     if ( !self :: $f_open )
                        {
                           self :: $f_open = fopen( $file, $modo );
                        }

                     if ( self :: $f_open )
                        {
                           fwrite( self :: $f_open, $contenido . PHP_EOL );

                           fclose( self :: $f_open );

                           chmod( $file, 0777 );
                        }
                  }
                  catch ( Exception $ex ) {
                     throw new Exception( "Error al escribir el archivo $file " . $ex -> getMessage( ));
                  }
               }
         }

      /**
       * 
       * Nombre         	: 	guardarContenido
       * Descripcion   	:	
       * Version 			:  	1.0
       * Autor:			:	Juan Jose Muñiz Juarez
       * Fecha y Hora		:	06/05/2012, 14:08:28
       * @param unknown_type $contenido
       * @param unknown_type $archivo
       * @param unknown_type $eliminar_archivo
       */
      public static function guardarContenido( $contenido, $directorio, $archivo, $eliminar_archivo = true )
         {
            if ( $eliminar_archivo )
               {
                  self :: eliminarArchivo( $directorio . $archivo );
               }

            $guardar = true;
               
            if ( !self :: existeCarpeta( $directorio ) )
               {
                  self::generarDirectorio( $directorio );
                  
                  $guardar = self :: existeCarpeta( $directorio );
               }
          
            // var_dump( "Guardando " . $guardar );
               
            if ( $guardar )
              {
                 $archivo = str_replace( " " , "" , $directorio . $archivo );
                 
                 file_put_contents( $archivo, $contenido );
              }
         }

      /**
       * 
       * Metodo: eliminarArchivo
       * Descripcion: 
       * Fecha de Creacion: 26/03/2012 16:20:33
       * Autor: Juan José Muñiz Juárez
       * params: @param unknown_type $file
       * return: return_type
       */
      public static function eliminarArchivo( $file )
         {
            if ( self :: existeArchivo( $file ) )
               {
                  if ( is_file( $file ) )
                     {
                        chmod( $file, 0777 );

                        return unlink( $file );
                     }
               }

            return true;
         }
   }

  // OperacionArchivo::generarDirectorio( "C:/wamp/www/SITKD/sistema/tmp" );
//  OperacionArchivo::obtenerArrayArchivosDirectorio( "C:/wamp/www/SITKD/sistema/config/idiomas" );